/**
 * 研发流程角色配置文件
 * 定义系统中的角色、权限和角色切换功能
 */

// 使用项目自带的助手工具
const timeHelper = require('./project_helpers_config').timeHelper;
const pageHelper = require('./project_helpers_config').pageHelper;

/**
 * 角色定义
 * 系统中所有可用角色
 */
const ROLES = [
  { id: 'admin', name: '系统管理员', icon: 'icon-user', color: '#1976D2', priority: 100 },
  { id: 'director', name: '董事长', icon: 'icon-rank', color: '#F44336', priority: 90 },
  { id: 'research_manager', name: '研发经理', icon: 'icon-addressbook', color: '#673AB7', priority: 80 },
  { id: 'project_manager', name: '项目经理', icon: 'icon-friend', color: '#3F51B5', priority: 70 },
  { id: 'hardware_engineer', name: '硬件工程师', icon: 'icon-repair', color: '#FF9800', priority: 60 },
  { id: 'software_engineer', name: '软件工程师', icon: 'icon-form', color: '#4CAF50', priority: 60 },
  { id: 'tester', name: '测试人员', icon: 'icon-check', color: '#009688', priority: 50 },
  { id: 'business_staff', name: '业务人员', icon: 'icon-group', color: '#2196F3', priority: 50 },
  { id: 'purchaser', name: '采购人员', icon: 'icon-cart', color: '#8BC34A', priority: 40 },
  { id: 'production_supervisor', name: '生产主管', icon: 'icon-settings', color: '#795548', priority: 40 },
  { id: 'production_engineer', name: 'PE工程师', icon: 'icon-tools', color: '#607D8B', priority: 40 },
  { id: 'document_controller', name: '文控', icon: 'icon-file', color: '#9C27B0', priority: 30 },
  { id: 'sample_team', name: '样品组', icon: 'icon-share', color: '#CDDC39', priority: 30 },
  { id: 'secretary', name: '文秘人员', icon: 'icon-edit', color: '#795548', priority: 30 },
  { id: 'receptionist', name: '前台人员', icon: 'icon-phone', color: '#E91E63', priority: 20 },
  { id: 'warehouse_keeper', name: '仓库管理员', icon: 'icon-goods', color: '#FFC107', priority: 20 },
  { id: 'research_member', name: '研发人员', icon: 'icon-people', color: '#03A9F4', priority: 50 }
];

/**
 * 角色权限映射
 * 定义每个角色具有的基础权限
 */
const ROLE_PERMISSIONS = {
  admin: ['ALL'], // 管理员拥有所有权限
  
  director: [
    'VIEW_PROJECT', 'CREATE_PROJECT', 'EDIT_PROJECT', 'DELETE_PROJECT',
    'APPROVE_PROJECT', 'REJECT_PROJECT',
    'VIEW_STATISTICS', 'EXPORT_DATA',
    'VIEW_ALL_USERS', 'SET_USER_ROLE',
    'VIEW_DOCUMENTS'
  ],
  
  research_manager: [
    'VIEW_PROJECT', 'EDIT_PROJECT',
    'APPROVE_PROJECT', 'REJECT_PROJECT',
    'ASSIGN_TASKS', 'VIEW_STATISTICS',
    'VIEW_TEAM_MEMBERS', 'SET_PROJECT_PRIORITY',
    'VIEW_DOCUMENTS', 'UPLOAD_DOCUMENTS'
  ],
  
  hardware_engineer: [
    'VIEW_PROJECT', 'EDIT_PROJECT',
    'SUBMIT_DESIGN', 'REQUEST_REVIEW',
    'VIEW_DOCUMENTS', 'UPLOAD_DOCUMENTS',
    'RECORD_ISSUES'
  ],
  
  software_engineer: [
    'VIEW_PROJECT', 'EDIT_PROJECT',
    'SUBMIT_CODE', 'REQUEST_REVIEW',
    'REQUEST_SAMPLE', 'DEBUG_SAMPLE',
    'VIEW_DOCUMENTS', 'UPLOAD_DOCUMENTS',
    'SYNC_PROJECT_DATA'
  ],
  
  business_staff: [
    'VIEW_PROJECT', 'CREATE_PROJECT', 
    'REQUEST_PROJECT', 'EDIT_PROJECT',
    'VIEW_CUSTOMER_INFO', 'SUBMIT_FEEDBACK',
    'VIEW_DOCUMENTS'
  ],
  
  tester: [
    'VIEW_PROJECT', 
    'TEST_SAMPLE', 'RECORD_ISSUES',
    'APPROVE_TEST', 'REJECT_TEST',
    'VIEW_DOCUMENTS'
  ],
  
  // 其他角色权限配置（简化展示）
  purchaser: ['VIEW_PROJECT', 'SUBMIT_SAMPLE_ORDER', 'TRACK_ORDER', 'VIEW_DOCUMENTS'],
  sample_team: ['VIEW_PROJECT', 'RECEIVE_SAMPLE', 'INVENTORY_SAMPLE', 'VIEW_DOCUMENTS'],
  document_controller: ['VIEW_PROJECT', 'MANAGE_DOCUMENTS', 'ARCHIVE_PROJECT', 'VIEW_DOCUMENTS'],
  production_supervisor: ['VIEW_PROJECT', 'MANAGE_PRODUCTION', 'REPORT_ISSUES', 'VIEW_DOCUMENTS'],
  production_engineer: ['VIEW_PROJECT', 'SOLVE_PRODUCTION_ISSUES', 'UPDATE_DESIGN', 'VIEW_DOCUMENTS']
};

/**
 * 角色模拟配置
 */
const ROLE_SIMULATION = {
  // 是否启用角色模拟功能
  ENABLED: false,
  
  // 只有管理员能使用模拟功能
  ADMIN_ONLY: false,
  
  // 记录角色模拟操作
  LOG_ACTIONS: true,
  
  // 允许模拟的角色列表
  ALLOWED_ROLES: ROLES.map(role => role.id),
  
  // 模拟角色的默认权限级别 (1: 查看, 2: 编辑, 3: 管理)
  DEFAULT_PERMISSION_LEVEL: 2
};

/**
 * 权限名称映射
 * 将权限代码映射为中文显示名称
 */
const PERMISSION_NAMES = {
  // 项目管理权限
  'VIEW_PROJECT': '查看项目',
  'CREATE_PROJECT': '创建项目',
  'EDIT_PROJECT': '编辑项目',
  'DELETE_PROJECT': '删除项目',
  'APPROVE_PROJECT': '审批项目',
  'REJECT_PROJECT': '驳回项目',
  'SET_PROJECT_PRIORITY': '设置优先级',
  
  // 任务管理权限
  'ASSIGN_TASKS': '分配任务',
  'VIEW_STATISTICS': '查看统计',
  
  // 用户管理权限
  'VIEW_ALL_USERS': '查看所有用户',
  'SET_USER_ROLE': '设置用户角色',
  'VIEW_TEAM_MEMBERS': '查看团队成员',
  
  // 文档管理权限
  'VIEW_DOCUMENTS': '查看文档',
  'UPLOAD_DOCUMENTS': '上传文档',
  'MANAGE_DOCUMENTS': '管理文档',
  'ARCHIVE_PROJECT': '归档项目',
  
  // 硬件相关权限
  'SUBMIT_DESIGN': '提交设计',
  'REQUEST_REVIEW': '请求评审',
  
  // 软件相关权限
  'SUBMIT_CODE': '提交代码',
  'REQUEST_SAMPLE': '申请样品',
  'DEBUG_SAMPLE': '调试样品',
  'SYNC_PROJECT_DATA': '同步项目数据',
  
  // 业务相关权限
  'VIEW_CUSTOMER_INFO': '查看客户信息',
  'SUBMIT_FEEDBACK': '提交反馈',
  'REQUEST_PROJECT': '请求项目',
  
  // 测试相关权限
  'TEST_SAMPLE': '测试样品',
  'RECORD_ISSUES': '记录问题',
  'APPROVE_TEST': '通过测试',
  'REJECT_TEST': '驳回测试',
  
  // 采购相关权限
  'SUBMIT_SAMPLE_ORDER': '提交样品订单',
  'TRACK_ORDER': '跟踪订单',
  
  // 样品相关权限
  'RECEIVE_SAMPLE': '接收样品',
  'INVENTORY_SAMPLE': '盘点样品',
  
  // 生产相关权限
  'MANAGE_PRODUCTION': '管理生产',
  'REPORT_ISSUES': '报告问题',
  'SOLVE_PRODUCTION_ISSUES': '解决生产问题',
  'UPDATE_DESIGN': '更新设计',
  
  // 其他权限
  'EXPORT_DATA': '导出数据',
  'ALL': '所有权限'
};

/**
 * 获取所有角色列表
 * @returns {Array} 角色列表
 */
function getAllRoles() {
  return ROLES;
}

/**
 * 根据ID获取角色信息
 * @param {String} roleId 角色ID
 * @returns {Object} 角色信息
 */
function getRoleById(roleId) {
  return ROLES.find(role => role.id === roleId) || null;
}

/**
 * 根据ID获取角色名称
 * @param {String} roleId 角色ID
 * @returns {String} 角色名称
 */
function getRoleName(roleId) {
  const role = getRoleById(roleId);
  return role ? role.name : roleId;
}

/**
 * 检查角色是否有指定权限
 * @param {String} roleId 角色ID
 * @param {String} permission 权限标识
 * @returns {Boolean} 是否有权限
 */
function hasPermission(roleId, permission) {
  if (!roleId) return false;
  
  // 管理员拥有所有权限
  if (roleId === 'admin') return true;
  
  const permissions = ROLE_PERMISSIONS[roleId] || [];
  
  // 检查是否有全部权限标记或包含特定权限
  return permissions.includes('ALL') || permissions.includes(permission);
}

/**
 * 检查角色是否有事件权限
 * @param {String} roleId 角色ID 
 * @param {String} eventCode 事件代码
 * @returns {Boolean} 是否有权限
 */
function hasEventPermission(roleId, eventCode) {
  if (!roleId || !eventCode) return false;
  
  try {
    // 尝试加载状态机配置
    const ResearchStateMachine = require('./research_state_machine.js');
    const transitions = ResearchStateMachine.getTransitionsByEvent(eventCode);
    
    if (!transitions || transitions.length === 0) return false;
    
    // 管理员拥有所有事件权限
    if (roleId === 'admin') return true;
    
    // 检查角色是否在允许列表中
    return transitions.some(transition => {
      return transition.roles && transition.roles.includes(roleId);
    });
  } catch (e) {
    console.error('[角色权限] 检查事件权限失败', e);
    return false;
  }
}

/**
 * 获取角色模拟配置
 * @param {Array} userRoles 用户角色列表
 * @returns {Object} 角色模拟配置
 */
function getRoleSimulationConfig(userRoles = []) {
  const isAdmin = userRoles.includes('admin');
  
  return {
    enabled: ROLE_SIMULATION.ENABLED,
    adminOnly: ROLE_SIMULATION.ADMIN_ONLY,
    canEnable: isAdmin || !ROLE_SIMULATION.ADMIN_ONLY,
    allowedRoles: ROLE_SIMULATION.ALLOWED_ROLES,
    logActions: ROLE_SIMULATION.LOG_ACTIONS
  };
}

/**
 * 设置角色模拟功能启用状态
 * @param {Boolean} enabled 是否启用
 * @param {Array} userRoles 用户角色列表
 * @returns {Boolean} 操作是否成功
 */
function setRoleSimulationEnabled(enabled, userRoles = []) {
  const isAdmin = userRoles.includes('admin');
  
  // 移除权限检查，允许任何用户设置
  /*
  // 检查是否有权限更改
  if (ROLE_SIMULATION.ADMIN_ONLY && !isAdmin) {
    return false;
  }
  */
  
  // 更新配置
  ROLE_SIMULATION.ENABLED = !!enabled;
  
  // 记录到本地存储
  try {
    wx.setStorageSync('ROLE_SIMULATION_ENABLED', ROLE_SIMULATION.ENABLED);
    
    // 记录日志
    if (ROLE_SIMULATION.LOG_ACTIONS) {
      const logEntry = {
        action: enabled ? 'ENABLE_SIMULATION' : 'DISABLE_SIMULATION',
        timestamp: timeHelper.time('Y-M-D h:m:s'),
        operator: userRoles.join(',')
      };
      
      const logs = wx.getStorageSync('ROLE_SIMULATION_LOGS') || [];
      logs.unshift(logEntry);
      
      // 最多保留100条日志
      wx.setStorageSync('ROLE_SIMULATION_LOGS', logs.slice(0, 100));
    }
    
    return true;
  } catch (err) {
    console.error('[角色模拟] 设置启用状态失败', err);
    return false;
  }
}

/**
 * 获取角色模拟日志
 * @returns {Array} 日志列表
 */
function getRoleSimulationLogs() {
  return wx.getStorageSync('ROLE_SIMULATION_LOGS') || [];
}

/**
 * 清除角色模拟日志
 * @returns {Boolean} 操作是否成功
 */
function clearRoleSimulationLogs() {
  try {
    wx.removeStorageSync('ROLE_SIMULATION_LOGS');
    return true;
  } catch (err) {
    console.error('[角色模拟] 清除日志失败', err);
    return false;
  }
}

/**
 * 获取角色与权限对比表
 * @returns {Object} 角色权限对比表
 */
function getRolePermissionMatrix() {
  try {
    // 收集所有权限
    const allPermissions = new Set();
    Object.values(ROLE_PERMISSIONS).forEach(permissions => {
      permissions.forEach(perm => {
        // 跳过特殊ALL权限
        if (perm !== 'ALL') {
          allPermissions.add(perm);
        }
      });
    });
    
    // 将权限转换为数组并排序
    const permissionArray = Array.from(allPermissions).sort();
    
    // 构建权限对象
    const permissionObjects = permissionArray.map(perm => ({
      code: perm,
      name: PERMISSION_NAMES[perm] || perm
    }));
    
    // 定义常用角色顺序
    const commonRoles = ['admin', 'research_manager', 'director', 'hardware_engineer', 'software_engineer'];
    
    // 获取所有角色对象
    const allRoles = [...ROLES];
    
    // 按照常用角色顺序排序
    allRoles.sort((a, b) => {
      const indexA = commonRoles.indexOf(a.id);
      const indexB = commonRoles.indexOf(b.id);
      
      // 如果都不在常用角色列表中，按原顺序排列
      if (indexA === -1 && indexB === -1) return 0;
      
      // 如果只有一个在常用角色列表中，那个在前面
      if (indexA === -1) return 1;
      if (indexB === -1) return -1;
      
      // 如果都在常用角色列表中，按列表顺序排列
      return indexA - indexB;
    });
    
    // 构建矩阵数据
    const rolePermissionMap = {};
    allRoles.forEach(role => {
      rolePermissionMap[role.id] = {};
      permissionArray.forEach(perm => {
        rolePermissionMap[role.id][perm] = hasPermission(role.id, perm);
      });
    });
    
    // 角色列表
    const roleList = allRoles.map(role => ({
      id: role.id,
      name: role.name,
      icon: role.icon,
      color: role.color
    }));
    
    console.log('[角色配置] 生成权限矩阵完成', {
      permCount: permissionObjects.length,
      roleCount: roleList.length
    });
    
    return {
      permissions: permissionObjects,
      roles: roleList,
      data: rolePermissionMap
    };
  } catch (err) {
    console.error('[角色配置] 生成权限矩阵失败', err);
    return {
      permissions: [],
      roles: [],
      data: {}
    };
  }
}

/**
 * 获取权限的中文名称
 * @param {String} permissionCode 权限代码
 * @returns {String} 权限中文名称
 */
function getPermissionName(permissionCode) {
  return PERMISSION_NAMES[permissionCode] || permissionCode;
}

// 模块导出
module.exports = {
  ROLES,
  ROLE_PERMISSIONS,
  ROLE_SIMULATION,
  PERMISSION_NAMES,
  getAllRoles,
  getRoleById,
  getRoleName,
  hasPermission,
  hasEventPermission,
  getPermissionName,
  getRoleSimulationConfig,
  setRoleSimulationEnabled,
  getRoleSimulationLogs,
  clearRoleSimulationLogs,
  getRolePermissionMatrix
}; 